{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#skip\n",
    "! [ -e /content ] && pip install -Uqq fastai  # upgrade fastai on colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp vision.core\n",
    "#default_cls_lvl 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai.torch_basics import *\n",
    "from fastai.data.all import *\n",
    "\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.data.external import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "_all_ = ['Image','ToTensor']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#It didn't use to be necessary to add ToTensor in all but we don't have the encodes methods defined here otherwise.\n",
    "#TODO: investigate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Core vision\n",
    "> Basic image opening/processing functionality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "imagenet_stats = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "cifar_stats    = ([0.491, 0.482, 0.447], [0.247, 0.243, 0.261])\n",
    "mnist_stats    = ([0.131], [0.308])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = Image.open(TEST_IMAGE).resize((30,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "if not hasattr(Image,'_patched'):\n",
    "    _old_sz = Image.Image.size.fget\n",
    "    @patch(as_prop=True)\n",
    "    def size(x:Image.Image): return fastuple(_old_sz(x))\n",
    "    Image._patched = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch(as_prop=True)\n",
    "def n_px(x: Image.Image): return x.size[0] * x.size[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.n_px`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> `Image.n_px` (property)\n",
    "\n",
    "Number of pixels in image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.n_px, 30*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch(as_prop=True)\n",
    "def shape(x: Image.Image): return x.size[1],x.size[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.shape`\n",
    "\n",
    "> `Image.shape` (property)\n",
    "\n",
    "Image (height,width) tuple (NB: opposite order of `Image.size()`, same order as numpy array and pytorch tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.shape, (20,30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch(as_prop=True)\n",
    "def aspect(x: Image.Image): return x.size[0]/x.size[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.aspect`\n",
    "\n",
    "> `Image.aspect` (property)\n",
    "\n",
    "Aspect ratio of the image, i.e. `width/height`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.aspect, 30/20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def reshape(x: Image.Image, h, w, resample=0):\n",
    "    \"`resize` `x` to `(w,h)`\"\n",
    "    return x.resize((w,h), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.reshape\" class=\"doc_header\"><code>Image.reshape</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.reshape</code>(**`x`**:`Image`, **`h`**, **`w`**, **`resample`**=*`0`*)\n",
       "\n",
       "`resize` `x` to `(w,h)`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.reshape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.reshape(12,10).shape, (12,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def to_bytes_format(im:Image.Image, format='png'):\n",
    "    \"Convert to bytes, default to PNG format\"\n",
    "    arr = io.BytesIO()\n",
    "    im.save(arr, format=format)\n",
    "    return arr.getvalue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.to_bytes_format\" class=\"doc_header\"><code>Image.to_bytes_format</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.to_bytes_format</code>(**`im`**:`Image`, **`format`**=*`'png'`*)\n",
       "\n",
       "Convert to bytes, default to PNG format"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_bytes_format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def to_thumb(self:Image.Image, h, w=None):\n",
    "    \"Same as `thumbnail`, but uses a copy\"\n",
    "    if w is None: w=h\n",
    "    im = self.copy()\n",
    "    im.thumbnail((w,h))\n",
    "    return im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.to_thumb\" class=\"doc_header\"><code>Image.to_thumb</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.to_thumb</code>(**`h`**, **`w`**=*`None`*)\n",
       "\n",
       "Same as `thumbnail`, but uses a copy"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_thumb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def resize_max(x: Image.Image, resample=0, max_px=None, max_h=None, max_w=None):\n",
    "    \"`resize` `x` to `max_px`, or `max_h`, or `max_w`\"\n",
    "    h,w = x.shape\n",
    "    if max_px and x.n_px>max_px: h,w = fastuple(h,w).mul(math.sqrt(max_px/x.n_px))\n",
    "    if max_h and h>max_h: h,w = (max_h    ,max_h*w/h)\n",
    "    if max_w and w>max_w: h,w = (max_w*h/w,max_w    )\n",
    "    return x.reshape(round(h), round(w), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.resize_max(max_px=20*30).shape, (20,30))\n",
    "test_eq(im.resize_max(max_px=300).n_px, 294)\n",
    "test_eq(im.resize_max(max_px=500, max_h=10, max_w=20).shape, (10,15))\n",
    "test_eq(im.resize_max(max_h=14, max_w=15).shape, (10,15))\n",
    "test_eq(im.resize_max(max_px=300, max_h=10, max_w=25).shape, (10,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.resize_max\" class=\"doc_header\"><code>Image.resize_max</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.resize_max</code>(**`x`**:`Image`, **`resample`**=*`0`*, **`max_px`**=*`None`*, **`max_h`**=*`None`*, **`max_w`**=*`None`*)\n",
       "\n",
       "`resize` `x` to `max_px`, or `max_h`, or `max_w`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.resize_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section regroups the basic types used in vision with the transform that create objects of those types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def to_image(x):\n",
    "    \"Convert a tensor or array to a PIL int8 Image\"\n",
    "    if isinstance(x,Image.Image): return x\n",
    "    if isinstance(x,Tensor): x = to_np(x.permute((1,2,0)))\n",
    "    if x.dtype==np.float32: x = (x*255).astype(np.uint8)\n",
    "    return Image.fromarray(x, mode=['RGB','CMYK'][x.shape[0]==4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def load_image(fn, mode=None):\n",
    "    \"Open and load a `PIL.Image` and convert to `mode`\"\n",
    "    im = Image.open(fn)\n",
    "    im.load()\n",
    "    im = im._new(im.im)\n",
    "    return im.convert(mode) if mode else im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def image2tensor(img):\n",
    "    \"Transform image to byte tensor in `c*h*w` dim order.\"\n",
    "    res = tensor(img)\n",
    "    if res.dim()==2: res = res.unsqueeze(-1)\n",
    "    return res.permute(2,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILBase(Image.Image, metaclass=BypassNewMeta):\n",
    "    _bypass_type=Image.Image\n",
    "    _show_args = {'cmap':'viridis'}\n",
    "    _open_args = {'mode': 'RGB'}\n",
    "    @classmethod\n",
    "    def create(cls, fn:(Path,str,Tensor,ndarray,bytes), **kwargs)->None:\n",
    "        \"Open an `Image` from path `fn`\"\n",
    "        if isinstance(fn,TensorImage): fn = fn.permute(1,2,0).type(torch.uint8)\n",
    "        if isinstance(fn, TensorMask): fn = fn.type(torch.uint8)\n",
    "        if isinstance(fn,Tensor): fn = fn.numpy()\n",
    "        if isinstance(fn,ndarray): return cls(Image.fromarray(fn))\n",
    "        if isinstance(fn,bytes): fn = io.BytesIO(fn)\n",
    "        return cls(load_image(fn, **merge(cls._open_args, kwargs)))\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        \"Show image using `merge(self._show_args, kwargs)`\"\n",
    "        return show_image(self, ctx=ctx, **merge(self._show_args, kwargs))\n",
    "\n",
    "    def __repr__(self): return f'{self.__class__.__name__} mode={self.mode} size={\"x\".join([str(d) for d in self.size])}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILImage(PILBase): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILImageBW(PILImage): _show_args,_open_args = {'cmap':'Greys'},{'mode': 'L'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILImage.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILImage)\n",
    "test_eq(im.mode, 'RGB')\n",
    "test_eq(str(im), 'PILImage mode=RGB size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64 at 0x7F76612AA7D0>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEYAAAAzCAYAAAAqwX72AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAWSUlEQVR4nO2aSaxu2XXXf7s5+3Rfe797372v3vOrKpfL5VJVxbEdy60cByeOIwcJoQRlECRkEEJJgASEhBiABAPEiCkSjZQERwgsZUAkRCAOwTSxoVI2jmO7yq7mtbf/mvOdbp/dMPiewgC9a/RqABK1pmdw9vmdtdZe///eIsbIO/G/h/y/vYD/V+MdMI+Id8A8It4B84h4B8wjQl/18Mu/85/iMLRYr3jq5hHL1QVKaYqiwNoeYzJG4xEX55ecnN5HCsWX/tW/5D//3u9SZgUf+OEf5i/+8q8wnsyYT6e0XY0AdJLQdxYfA5LIYn+Ppumw1rHdLNlb7JPlOcPQ03U93oNWisENWGtxg0dridaGtu2YziYoKTk5PUUKCUTOzs6ZTCYMzlNVK7QZI/HkmeHu3QdY2/OFP//z4lHffmXGpEajlCZLU0KMTKcTTJphUsPe3h5pltA0Ld5bXnjhBZ599ln+0i/8VT756U8zOMt3Xvs+f/SNP2A6KdlsVgzWkuUFSgqyPKXZNpycnrNeLWmbDq0Et556mnJUEoIj+EiSaNI0QUiBVBopFUVRoLRBiMBiMSNGT1VVGGMQSiOVZDqdoE0K0TOfzcmzlGsHC9q2Zb43A3l1sVyZMRGYTMa0bUOaJSiVEeuavuvxPuDcQJrlJBKkgCzPmAv4xV/6a7z81f/KxXrJF3/t13jv889zeP0WTbul7XqaaslXf+/LfOO/v0xXbzFpzo2nnuYjP/qjvPf558nzETFCYhK6riPPM/reYkwKIZDlGXme03UN69UKkAgpSIRC+EDbWIrRmPVqiRCRxf6C8/NzLpdLirKgc4rxqLsSjLhqwHv55Vei1oqmbkjTFCEVUiUE7+iaFUU5wXuHkClGS+aLOW3bMAyBf/qP/xG/8cV/zijLeebWE/zNv/f38bbjWy9/jW+9/N9Ynl8gokAlGikU0mTItODm00/xsU99ih/52McAsNZSFAV13ZLlGcSIlJLttsI5h5KKuq7xwSOQRCRdVxPRFLnh9OQY7yOJSXA+khrD+ekx5XjCZz/7Jx5ZSldmTNt5Dq9NqdYVwQSazRaVZIzHY0w+Ic0KmmpJEBCEpOksWZph+zU/+bnP8xtf/HXqtubu3fv8+j/8BzjnODs9Y9u2RAS5MZRpyijPMEGSi4TN6Qn/7l//Frbv+dSPfwaTlKw3G4SQeDc8zFRL3w/kWfYwswyZlOgkoW17lB5TFiOWywvyvKCzlixLuVjWmASQEoG6MmOuLDSBw9oBqSXOOWbzPabjEYkSFMWYelshdEGIjsm4xGhJ11m0EkwnI378J36SPNE8MZ/w1ptv8trrb3CyXGNdxIfA4D0B2HaWtnd0XY/oajJb842vfIVvvfLKrkQSQ1EUSKlQSrFYLAghIKQiEkiMQWnFZtsx2B6tFJfLC9KsoJzMSLMSHxRlpnFuYDJdIMQjk+X/AIyzuz+SaBCGJNH44NhWG0QcmMzmjCclhwd7WGtZb2rcYDFpSZYZPvOZn+DmfMZFVbNpO6rOEmKkcw4fQCcZdWexUTCECElGkAkxRrrLE77227/FMFi0ljg3oJQkSfTDnbEEITAmpQ8JXb1hu61QwhPDgJYSa3t8EEgzomka0jRjsB1SSvb2964Ec2UpWR85P3vAwbUDbO9JswKlJLPpFKkkMUacjzgHUihisHR9Q4jgPPzmr/4TTqsG5x1aShACIXaNOtEJqTEcTPfI85yLTYsQkkRG0tRglGSoa778pX/Bi5/4NOV4QowBJTVCgFIKpSRSKVJR06uUPPFkRYG1jhgjWgl88FzfnzLUlyilKEdjmrrm7KR9fDDT2RSpdtujEB3edRhjSEzCdtsghMD7SJYmbLsOrRVeZFxeXvKNr/0XXr99h8H7h2AMSkoG5zGJ4N1Hexzt7SGlAp2S6AQtBG6wXJ61pGUJCOqvvcx3vvltFtcO2X/iOiEE9vcXHD71DPNrR6RSsNnUlIUhNQakoe46ilSjtaG3PX3Xk2eGSETrlKIMxHh1j7kSjA8RIQLLdU2aKASS4CFNM+q6QkrD6ekD9hcHKClARCDSDYGv/u5v40IkIrDOIRHkUjIrMp67eUgiBG/cO0ZLwXiyoPFhBzoEUm0IQ6RzlqbrCZcbzk7PSL77Gu36koKBg1tP8uHPfZ4XP/oJrj9xiHeWOJowuIH5dErfd1TVmtl8xmZTMx4V9NayrS1Ga1ab6vHBFHmBUoJt05DnJd4HrO2pqi2CXfPSSiDVLnOCDywvl7i+5fL4ATFGAuB8RBpJoiQfePI6dy83uChoBo/0Fp2OaH1E6QSpNUFKbN+DlKy2W4xOqOqBwVrmmeFisyQkGV/5zS9x7/vf41N/6mcwWYZSIJQgSI1SBVlqKMqC5XJNQGOtJU01IQSkSq8Ec2Xz3awviECZKkLwnDy4jw4Ngwu7MpOS8XiCGzxKayIR5y3bzQX5qARg8AEhIBJ5djHhjdMlr1+sWbUdIUa8Kbhzeko7OGKS4EMkErF9h+saEqUYhgGtNMvVJbcf3ON+1dA1HfW25fd/5z/wb371n9E2Lc62DM4hpUDKiJCCqtqQZRkCUCphUzUIIiraxweDNHgXiMmM1fKSoizYtgNKgkBguwaTZkglsX2Lsw1tvcWkBbO9PQLxj7fFGCPCO87rlm6wWNszRIEN0HiPDRGBIMZAtVlxfHZCVVWEoUdJwXS+x8HBEe0wcG+9ZtUPtJ1lawfeePU1Xv/Dr9N3HUGkgGA0GjE4hxKSsixJTIZONNcWU4bBIbV5fDCvv3UPO3i8G4hCM58vkFKgpGK1XjO4gb7v6NstwfVIIUjzMffPNugkRcSHUNiBrDpL1dQEH+idJ89z7p48oGo7lIToLL7vsH3HaluxbSrOL87pmwrRNzz7/Au8+ML76ZwnyXICirIo6O3Ane+9RpqP6NqaEAPr9ZrMpGw2S1KTkiQpSkmEVChtCN49PpgPvv95RmVGmQv25lOkhGI8ZbW6JARBUY5o2xqpFElW4kkAiQqWVmRoEXYLiBGlBG+taxIRcd7h3cC6rllXG5ztUVJysVqyWl9yfnnB4ALHyxVn6zVtXdM3DUZJ9p+4ydH+NdZNg9AKnWZY57n13PP0tqdqWvK8YLO6ZL1tmS+O6PsGIQJ788VufRKK0eTxwcTgcW6gazuE0EhlEFKR5ykxOOpqjdYGhKbvB5zzNNslZVmwd3SdUbb7MyFGlBDUdqBMFCJGBHByfrbrIW6gsz1aay42G842G9b1ltW2pu57TtdLBjdAjIgQuLWYc1lVJEkCgIiO97zwIonWHC1mJFqTFyPSRNFah04yfBAsl0vqumI8GWPt2+gx27ql63oGFxishQhaafIsxfYtSZpTFAU87CWr5ZJ1VaG1ZjQac/OZZ8mUxPvA4HYeymU3ME41mZZs24ZUSVprWa83jIwhT1N8iPjgkYKdaBSSKATb3nL24B7T0RjiruG32w0f+uTH0UlCmqWkqaFtGxJjGI0KRpkmRk8MEKMgzRI2mw2Rq09HfoBW8hhjMGmBlNC1W9brFW3XI5Umy3K6tidJEpQSzOYzpNIMtmN/f8H06CY3bz5BYTTWeTKt8GG3hRu1e3WWpmRpRjMM3Du+j46BeVmQm5TUJIQI1nneOD7mcr1hCJHReEwgIqPj+Zee4/M//+eo6y0h/C+bRQhB33dIpdE6AQZMmjCdznEuUPVvA8z+/j5NU6OkJ3hL17XkRUmalYwnU9q2Y7NZce/uHUAhheDWu97FeDzm2uEh+/sHHD31HHuLPYYYGUKkMJp+8CgiIQSMVkzKETpJuHN+zvHlJWNjmOYp86JESmi9Y37tBuloQtVZVGJQwHyS8bO/8CvM9vYwaQ4ElE7w3pEmGiEEm2qDtZa+68jznLpuGY3GPHU0e3wwfW/RKrBenmOHQNv1CHaap9pUDF5QFCUHB0esVktCBCklxahEK8V8vsdsMiKfzjk8uk6LQAhBqhV1PyABJSKTsiRLM/JywhAFeZIwyTLGJqEwGR948QM8/yMf4V3PPkcSB7RWzPOUP/2Lv4zSCSEEQohslkts32P7Dm0MqUnoncc7i1SK7bZiGHq0iixXmyvBXDn5np8+YDyeMDhHbz1RGISEar0iTXPafkCnOYKIjZKxMWgtaeoa5xyL/X2MeRGT5zy4fxd1O6G6OKVIFE1nSZRkGAbeuneb99y4hShy1GTM/ny6GxHcwPW9BdfGI47KEZvLcxaTEVkSuDafcXTrKapqy2AtOjGMxzvnz/tI3/fEGMmShLZtGY1HWOsQQlI3LaNR/vhgkCkmG9MPS6SULA4OiH4n23vnSBKBkpp6W3Ewn5KlhrreYNKMyXROXpT0fcfh4SF5kbO3f53b3/06m+P7LF1AC8HJpub6bMwfvvkGeWrYn0y59uyz1Ns1sm+YX7+FWRzw7f/xBzw4ucdHX3ofi8M96mqDkIosz+i6jiLPdqO+lIzHY3prGQYPviPGyLbaYtKUPM9ww8C2vlpdX1lKJw/u4ZxnsX+AdwN5KtlsKtquYwiSwUX80JNmGdPJBIEHFMSISRKkgOl0yt7+AYvFPjeuH1BvNuRaIoRASYnRiv1RjtaCGDxD30FwHF07ZDyZMJrvjOzt6gw5dCQazi4qXvr4J3dmlZA7ORJ30sMNA1JptlWF8wGlM6x1KK1Rare2LE93LeFxwRxefxd3791luVyRJJLz87OdEx8jDFvGZYZJc9I0JU0VMXiUEoQQqJsGISUhBJIkpShynPdkJsWFSKJ2W7CWigfrhnGek5sEQUAKGOUpk7LcjfPRM0k1T988ou09q6rne9/8Ft4NaBGQD2WHUprIrjcWRYmWkRA809kcHxRKyl0v2lQI9QOK5aqHq7rn/K3vEkJk/2Cfvh9obQClmYxH9EMgssuKar0mBEGiJIvFPmU5QsTAeDxmNhth24bZdMKNo0PubxomWUJpEhKtGXzgYFygpSJLU2SMZDJgVMSkKUpCmgjKyZjX753yzW99k7zciVRlMrq2Qeud2EzTlCTRSKXwPlJtNyQmIc92U/lytWIyW6D02wBTN1ueefFDlOWIN998kyLPGZcpEk9iMu6eriiKks16hY+Kru/wUeD9wGxakGjN/mJB33VM5gfE6NEiIhFEBNdGGYfjgpvz6c6mTFOefvIZsrzgzde/z4O79/ijV75K9AGTptw+XXL77m3atub2G98HIXBDQKidCdV1DVKK3awUHPP5nLIY03ftziW8uKAsUvI0uRLKDwRzbW/O3mKBiJbBOkIU4D2SSNe23NwfYYxitd5gjEGpBIQCIbF2N1BttytGoykIyXh6jd47JlmCkpK9Ucknfuh9/NRP/zSjNMUNAzF6vOuJyZhsuk+md8AOn3mBdT8gleTHPvNjfPZn/wzO7ywKYxJiFKgkp2kaBGBMuisZsVP2J8fHNE1FYjLOzi/o6tWVYK7Mp8XemLOzB0wnI25eP0AoiEhG0zneCyZlytnpCVImOGdBCJqmJdGKJNlNroMLXK7XRARvvv4q67NzolDkSYJUmtmtd/PRz32eO3fv8Nbp73Pn5IQsat77vh+imE7pzt8kek86nvKFX/rLDM2WYjziQx/5OFEIhsFijKHtHXmq2W4bEDuhuDsoTEEodGJ2juPJA4TOKMvi8cEc37/P9RtPsLw4Z7Z3SK4EWjgIAYFGK4n3kWHo2W4dRTHaHYC1HfO9Pc5OjzHGUOaGNJlyOVuwbTtq60BIyiCpV0sSrfncz/wcX3/lFXItuXP/NmWecuPGu5gWKeQFt977LM889z6kEJjUYK0lAjEEtFYkKjIMjiTJKPKM1WqFcxYTEno70DZbiiJjUw0I+IHb9ZVgBucwiSYxBauqR4oc123IxzMIHZdna5Qesbc3ous6ousYYsJiPqPrtmilCEnKbDYlBFhtKk42NTF42mGg7WquPfluTF5y8+kZf+Pv/F2+8R//PV3TU1cVxJb9d7/E5PCI97z4EpPpFNv3uMHSuMBsNmG9Wj/UQwrv/cOZpWIYBsbTKX3Xo4Ujz3NihKLIOT07p8jLxwcTh4bbb71BOVrQVJfk6T5JOtmp1HxEtdyiZcC5QFGUtPUGiSMvpmyqNQFBWeTEmLN56MZVTYsUklKD33nn4AdUmjO+8Qw/91c+iBLw5qvfQRvDjVtPEVVCP3gAlNZ477H9QN8PhLjzmi+2PaWJ+CgJwe8g9RE3eKSI1E2LVAlaaYo85eL8+EowVzbfJ59+N5v1lu3mEiU8Wkkk7CxHPxBJUMIRXIvta+JDi/zs9AFKKbIsw/tI11RYF/jKl/8tERiVY0bjObqY0bctXdfhmiWLSclsPqcfHC99+ONcu3EDmRi8c1x2Gu8cbbfzUZIkIUkS3OBomproLW3TPPSQdpnTtR0BqNsWpRRaS9q2xnUVhwf7byNjEBwcXqcfHNIPeO/xzmHSlJPje0SRoY0h+Mjg+j+2C+umY7HYuWVa9kRKSjlwdnpCluW7ayXBs9qs2JweM1tcQ0bHfH+P05NTcmlp247FwSFN0+CcYyx6mlaRpjnD0CGVYhg6QvQYbbhcW8apxFuH1hrbtmRpxuXyAq0TvOtZL0+JwqDTCXXXP37G3L93B+chhkhQKVXdYW1LkWdsty1919A0LW0fsIPHDo7JZMxkOqNtW2IMDz/AYkzCBz/8ERIpwDu6pmFR5jz10kskiUIbw727d4lIopkyDD3OOUyS0HYdUiesVmtCcGhtGAbLarlECE3X9ozTSAjQ9B5rLZv1mq7vdndpxO6HNn0gy1JCBCHfxqH+ZlMxmUzQWqGkIroe33coJcjyETpJWa7W5LlBSkma5qyWF9jeslxeoLQiAm1TM5tN+LNf+Atcv37ItYMFWWr4/J/8KZ55/4fJ85LVcokxO8Pr5LImNZqu7QBFWZZ0XctotDvnitEj5U4jheB2Z11nt/EhcnFxiR0c0/kcCLR1RT94fNyNlccXq92uJt6Guo5oBJEYI0pBluYE77i4OCMxKW3XMZ7us16vGFzg6NoeJxfHjGYZh0c36PuBi/MT8rwkzzJSk/LX/9bfpt1u+e6rr/LBT3ycdDSBGHA+oqRECMliNsKFiPeBtrdMp1NiDDRNvZtqvSf4QFGWdN2Gsiwx5gmqumdc7N6zWZ/TNVtCTHjixhFnZ+dsVpfkixtcXF4y3zt4O2B2jVYIRbVe0mnJ/uF1zo7vUoz3KfOCtt1Nl1makmXp7k8KR3QtQujd+c7guX//LnlR0FvDdDrhuRc/QH15jEkzTk4esLfYZ7AObweKUUEIHiEkZZFxcXFOkRuOj9d0FjJj8N5xee8Bi70ZvR3Is5Sm2Rnxr736bfLMMJ7sQQycnZ0Rg6cYTTk6uEZXb3DOXwnmylLK0oyua2nrNV1XI3VClmb01nJ6csp33rhHoiXNdou1DjtYXBA8OFmybQaq7W5mITra7QYpk921kmzEG3fuoIopeZ6xrWqaQdO2DdvVGSIGqsZispLz89PdEJdkzKZjJBalBEqph9c6HCHCcrmibRru372DlIrFwRHOWTovqLYNk+mc9fqS5cU527phub7awbvyqtn/z/HOPd9HxDtgHhHvgHlEvAPmEfEOmEfEO2AeEf8TsSPHS2OM2dEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = im.show(figsize=(1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fig_exists(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timg = TensorImage(image2tensor(im))\n",
    "tpil = PILImage.create(timg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64 at 0x7F766129ADD0>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpil.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "test_eq(np.array(im), np.array(tpil))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILMask(PILBase): _open_args,_show_args = {'mode':'L'},{'alpha':0.5, 'cmap':'tab20'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILMask.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILMask)\n",
    "test_eq(im.mode, 'L')\n",
    "test_eq(str(im), 'PILMask mode=L size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "OpenMask = Transform(PILMask.create)\n",
    "OpenMask.loss_func = CrossEntropyLossFlat(axis=1)\n",
    "PILMask.create = OpenMask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist = untar_data(URLs.MNIST_TINY)\n",
    "fns = get_image_files(mnist)\n",
    "mnist_fn = TEST_IMAGE_BW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA4klEQVR4nGNgGEjgu/Xf//gIrFLMiZ/+/v3793cpPxZJkWN/IeC9NUKQCUq/Wfab4fv9VwwMfP7YDM5r3MAQ/Pfv30MSWO2VYgj++/fvXwMMYxkYGBieMTAwMDAceIZVEgLOvsIhmYLVOgYGBgYGx29///5dz4Jdcs3fv3//uuHQ6fT379+/78ywSwo6vvj79+9UVhx6dXv//v1bjUVC8+zZs4pMDX//fk2GCSHcxmnAwLBlnQEDw6cbmDqNoNHy9wpcCBEIj/fhcAjEXKvNv//+/XtbB4d899+/TYb4DKA9AABLQV4KAJgjfgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "PILImageBW mode=L size=28x28"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timg = Transform(PILImageBW.create)\n",
    "mnist_img = timg(mnist_fn)\n",
    "test_eq(mnist_img.size, (28,28))\n",
    "assert isinstance(mnist_img, PILImageBW)\n",
    "mnist_img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Segmentation masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class AddMaskCodes(Transform):\n",
    "    \"Add the code metadata to a `TensorMask`\"\n",
    "    def __init__(self, codes=None):\n",
    "        self.codes = codes\n",
    "        if codes is not None: self.vocab,self.c = codes,len(codes)\n",
    "\n",
    "    def decodes(self, o:TensorMask):\n",
    "        if self.codes is not None: o.codes=self.codes\n",
    "        return o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "camvid = untar_data(URLs.CAMVID_TINY)\n",
    "fns = get_image_files(camvid/'images')\n",
    "cam_fn = fns[0]\n",
    "mask_fn = camvid/'labels'/f'{cam_fn.stem}_P{cam_fn.suffix}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_img = PILImage.create(cam_fn)\n",
    "test_eq(cam_img.size, (128,96))\n",
    "tmask = Transform(PILMask.create)\n",
    "mask = tmask(mask_fn)\n",
    "test_eq(type(mask), PILMask)\n",
    "test_eq(mask.size, (128,96))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,axs = plt.subplots(1,3, figsize=(12,3))\n",
    "cam_img.show(ctx=axs[0], title='image')\n",
    "mask.show(alpha=1, ctx=axs[1], vmin=1, vmax=30, title='mask')\n",
    "cam_img.show(ctx=axs[2], title='superimposed')\n",
    "mask.show(ctx=axs[2], vmin=1, vmax=30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class TensorPoint(TensorBase):\n",
    "    \"Basic type for points in an image\"\n",
    "    _show_args = dict(s=10, marker='.', c='r')\n",
    "\n",
    "    @classmethod\n",
    "    def create(cls, t, img_size=None)->None:\n",
    "        \"Convert an array or a list of points `t` to a `Tensor`\"\n",
    "        return cls(tensor(t).view(-1, 2).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        if 'figsize' in kwargs: del kwargs['figsize']\n",
    "        x = self.view(-1,2)\n",
    "        ctx.scatter(x[:, 0], x[:, 1], **{**self._show_args, **kwargs})\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "TensorPointCreate = Transform(TensorPoint.create)\n",
    "TensorPointCreate.loss_func = MSELossFlat()\n",
    "TensorPoint.create = TensorPointCreate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Points are expected to come as an array/tensor of shape `(n,2)` or as a list of lists with two elements. Unless you change the defaults in `PointScaler` (see later on), coordinates should go from 0 to width/height, with the first one being the column index (so from 0 to width) and the second one being the row index (so from 0 to height).\n",
    "\n",
    "> Note: This is different from the usual indexing convention for arrays in numpy or in PyTorch, but it's the way points are expected by matplotlib or the internal functions in PyTorch like `F.grid_sample`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pnt_img = TensorImage(mnist_img.resize((28,35)))\n",
    "pnts = np.array([[0,0], [0,35], [28,0], [28,35], [9, 17]])\n",
    "tfm = Transform(TensorPoint.create)\n",
    "tpnts = tfm(pnts)\n",
    "test_eq(tpnts.shape, [5,2])\n",
    "test_eq(tpnts.dtype, torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ctx = pnt_img.show(figsize=(1,1), cmap='Greys')\n",
    "tpnts.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bounding boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def get_annotations(fname, prefix=None):\n",
    "    \"Open a COCO style json in `fname` and returns the lists of filenames (with maybe `prefix`) and labelled bboxes.\"\n",
    "    annot_dict = json.load(open(fname))\n",
    "    id2images, id2bboxes, id2cats = {}, collections.defaultdict(list), collections.defaultdict(list)\n",
    "    classes = {o['id']:o['name'] for o in annot_dict['categories']}\n",
    "    for o in annot_dict['annotations']:\n",
    "        bb = o['bbox']\n",
    "        id2bboxes[o['image_id']].append([bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]])\n",
    "        id2cats[o['image_id']].append(classes[o['category_id']])\n",
    "    id2images = {o['id']:ifnone(prefix, '') + o['file_name'] for o in annot_dict['images'] if o['id'] in id2bboxes}\n",
    "    ids = list(id2images.keys())\n",
    "    return [id2images[k] for k in ids], [(id2bboxes[k], id2cats[k]) for k in ids]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test ```get_annotations``` on the coco_tiny dataset against both image filenames and bounding box labels. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = untar_data(URLs.COCO_TINY)\n",
    "test_images, test_lbl_bbox = get_annotations(coco/'train.json')\n",
    "annotations = json.load(open(coco/'train.json'))\n",
    "categories, images, annots = map(lambda x:L(x),annotations.values())\n",
    "\n",
    "test_eq(test_images, images.attrgot('file_name'))\n",
    "\n",
    "def bbox_lbls(file_name):\n",
    "    img = images.filter(lambda img:img['file_name']==file_name)[0]\n",
    "    bbs = annots.filter(lambda a:a['image_id'] == img['id'])\n",
    "    i2o = {k['id']:k['name'] for k in categories}\n",
    "    lbls = [i2o[cat] for cat in bbs.attrgot('category_id')]\n",
    "    bboxes = [[bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]] for bb in bbs.attrgot('bbox')]\n",
    "    return [bboxes, lbls]\n",
    "\n",
    "for idx in random.sample(range(len(images)),5): \n",
    "    test_eq(test_lbl_bbox[idx], bbox_lbls(test_images[idx]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "from matplotlib import patches, patheffects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def _draw_outline(o, lw):\n",
    "    o.set_path_effects([patheffects.Stroke(linewidth=lw, foreground='black'), patheffects.Normal()])\n",
    "\n",
    "def _draw_rect(ax, b, color='white', text=None, text_size=14, hw=True, rev=False):\n",
    "    lx,ly,w,h = b\n",
    "    if rev: lx,ly,w,h = ly,lx,h,w\n",
    "    if not hw: w,h = w-lx,h-ly\n",
    "    patch = ax.add_patch(patches.Rectangle((lx,ly), w, h, fill=False, edgecolor=color, lw=2))\n",
    "    _draw_outline(patch, 4)\n",
    "    if text is not None:\n",
    "        patch = ax.text(lx,ly, text, verticalalignment='top', color=color, fontsize=text_size, weight='bold')\n",
    "        _draw_outline(patch,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class TensorBBox(TensorPoint):\n",
    "    \"Basic type for a tensor of bounding boxes in an image\"\n",
    "    @classmethod\n",
    "    def create(cls, x, img_size=None)->None: return cls(tensor(x).view(-1, 4).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        x = self.view(-1,4)\n",
    "        for b in x: _draw_rect(ctx, b, hw=False, **kwargs)\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bounding boxes are expected to come as tuple with an array/tensor of shape `(n,4)` or as a list of lists with four elements and a list of corresponding labels. Unless you change the defaults in `PointScaler` (see later on), coordinates for each bounding box should go from 0 to width/height, with the following convention: x1, y1, x2, y2 where (x1,y1) is your top-left corner and (x2,y2) is your bottom-right corner.\n",
    "\n",
    "> Note: We use the same convention as for points with x going from 0 to width and y going from 0 to height."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class LabeledBBox(L):\n",
    "    \"Basic type for a list of bounding boxes in an image\"\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        for b,l in zip(self.bbox, self.lbl):\n",
    "            if l != '#na#': ctx = retain_type(b, self.bbox).show(ctx=ctx, text=l)\n",
    "        return ctx\n",
    "\n",
    "    bbox,lbl = add_props(lambda i,self: self[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = untar_data(URLs.COCO_TINY)\n",
    "images, lbl_bbox = get_annotations(coco/'train.json')\n",
    "idx=2\n",
    "coco_fn,bbox = coco/'train'/images[idx],lbl_bbox[idx]\n",
    "coco_img = timg(coco_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tbbox = LabeledBBox(TensorBBox(bbox[0]), bbox[1])\n",
    "ctx = coco_img.show(figsize=(3,3), cmap='Greys')\n",
    "tbbox.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unless specifically mentioned, all the following transforms can be used as single-item transforms (in one of the list in the `tfms` you pass to a `TfmdDS` or a `Datasource`) or tuple transforms (in the `tuple_tfms` you pass to a `TfmdDS` or a `Datasource`). The safest way that will work across applications is to always use them as `tuple_tfms`. For instance, if you have points or bounding boxes as targets and use `Resize` as a single-item transform, when you get to `PointScaler` (which is a tuple transform) you won't have the correct size of the image to properly scale your points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "PILImage  ._tensor_cls = TensorImage\n",
    "PILImageBW._tensor_cls = TensorImageBW\n",
    "PILMask   ._tensor_cls = TensorMask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@ToTensor\n",
    "def encodes(self, o:PILBase): return o._tensor_cls(image2tensor(o))\n",
    "@ToTensor\n",
    "def encodes(self, o:PILMask): return o._tensor_cls(image2tensor(o)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any data augmentation transform that runs on PIL Images must be run before this transform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ToTensor:\n",
      "encodes: (PILMask,object) -> encodes\n",
      "(PILBase,object) -> encodes\n",
      "decodes: \n",
      "<class '__main__.PILImageBW'>\n",
      "<class 'fastai.torch_core.TensorImageBW'>\n"
     ]
    }
   ],
   "source": [
    "tfm = ToTensor()\n",
    "print(tfm)\n",
    "print(type(mnist_img))\n",
    "print(type(tfm(mnist_img)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfm = ToTensor()\n",
    "test_eq(tfm(mnist_img).shape, (1,28,28))\n",
    "test_eq(type(tfm(mnist_img)), TensorImageBW)\n",
    "test_eq(tfm(mask).shape, (96,128))\n",
    "test_eq(type(tfm(mask)), TensorMask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's confirm we can pipeline this with `PILImage.create`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipe_img = Pipeline([PILImageBW.create, ToTensor()])\n",
    "img = pipe_img(mnist_fn)\n",
    "test_eq(type(img), TensorImageBW)\n",
    "pipe_img.show(img, figsize=(1,1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def _cam_lbl(x): return mask_fn\n",
    "cam_tds = Datasets([cam_fn], [[PILImage.create, ToTensor()], [_cam_lbl, PILMask.create, ToTensor()]])\n",
    "show_at(cam_tds, 0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    "> Warning: This transform needs to run on the tuple level, before any transform that changes the image size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _scale_pnts(y, sz, do_scale=True, y_first=False):\n",
    "    if y_first: y = y.flip(1)\n",
    "    res = y * 2/tensor(sz).float() - 1 if do_scale else y\n",
    "    return TensorPoint(res, img_size=sz)\n",
    "\n",
    "def _unscale_pnts(y, sz): return TensorPoint((y+1) * tensor(sz).float()/2, img_size=sz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PointScaler(Transform):\n",
    "    \"Scale a tensor representing points\"\n",
    "    order = 1\n",
    "    def __init__(self, do_scale=True, y_first=False): self.do_scale,self.y_first = do_scale,y_first\n",
    "    def _grab_sz(self, x):\n",
    "        self.sz = [x.shape[-1], x.shape[-2]] if isinstance(x, Tensor) else x.size\n",
    "        return x\n",
    "\n",
    "    def _get_sz(self, x): return getattr(x, 'img_size') if self.sz is None else self.sz\n",
    "\n",
    "    def setups(self, dl):\n",
    "        res = first(dl.do_item(0), risinstance(TensorPoint))\n",
    "        if res is not None: self.c = res.numel()\n",
    "\n",
    "    def encodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n",
    "    def decodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n",
    "\n",
    "    def encodes(self, x:TensorPoint): return _scale_pnts(x, self._get_sz(x), self.do_scale, self.y_first)\n",
    "    def decodes(self, x:TensorPoint): return _unscale_pnts(x.view(-1, 2), self._get_sz(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    "> Note: This transform automatically grabs the sizes of the images it sees before a <code>TensorPoint</code> object and embeds it in them. For this to work, those images need to be before any points in the order of your final tuple. If you don't have such images, you need to embed the size of the corresponding image when creating a <code>TensorPoint</code> by passing it with `sz=...`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _pnt_lbl(x): return TensorPoint.create(pnts)\n",
    "def _pnt_open(fn): return PILImage(PILImage.create(fn).resize((28,35)))\n",
    "pnt_tds = Datasets([mnist_fn], [_pnt_open, [_pnt_lbl]])\n",
    "pnt_tdl = TfmdDL(pnt_tds, bs=1, after_item=[PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(pnt_tdl.after_item.c, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y = tfm(pnt_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.img_size, x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = pnt_tdl.one_batch()\n",
    "#Scaling and flipping properly done\n",
    "#NB: we added a point earlier at (9,17); formula below scales to (-1,1) coords\n",
    "test_close(y[0], tensor([[-1., -1.], [-1.,  1.], [1.,  -1.], [1., 1.], [9/14-1, 17/17.5-1]]))\n",
    "a,b = pnt_tdl.decode_batch((x,y))[0]\n",
    "test_eq(b, tensor(pnts).float())\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorPoint)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorPoint)\n",
    "test_eq(b.img_size, (28,35)) #Automatically picked the size of the input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pnt_tdl.show_batch(figsize=(2,2), cmap='Greys');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class BBoxLabeler(Transform):\n",
    "    def setups(self, dl): self.vocab = dl.vocab\n",
    "\n",
    "    def decode (self, x, **kwargs):\n",
    "        self.bbox,self.lbls = None,None\n",
    "        return self._call('decodes', x, **kwargs)\n",
    "\n",
    "    def decodes(self, x:TensorMultiCategory):\n",
    "        self.lbls = [self.vocab[a] for a in x]\n",
    "        return x if self.bbox is None else LabeledBBox(self.bbox, self.lbls)\n",
    "\n",
    "    def decodes(self, x:TensorBBox):\n",
    "        self.bbox = x\n",
    "        return self.bbox if self.lbls is None else LabeledBBox(self.bbox, self.lbls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "#LabeledBBox can be sent in a tl with MultiCategorize (depending on the order of the tls) but it is already decoded.\n",
    "@MultiCategorize\n",
    "def decodes(self, x:LabeledBBox): return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@PointScaler\n",
    "def encodes(self, x:TensorBBox):\n",
    "    pnts = self.encodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)\n",
    "\n",
    "@PointScaler\n",
    "def decodes(self, x:TensorBBox):\n",
    "    pnts = self.decodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _coco_bb(x):  return TensorBBox.create(bbox[0])\n",
    "def _coco_lbl(x): return bbox[1]\n",
    "\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_bb], [_coco_lbl, MultiCategorize(add_na=True)]], n_inp=1)\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y,z = tfm(coco_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.img_size, x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Categorize -- {'vocab': None, 'sort': True, 'add_na': True}:\n",
       "encodes: (object,object) -> encodes\n",
       "decodes: (object,object) -> decodes"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Categorize(add_na=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(#3) [Pipeline: PILBase.create,Pipeline: _coco_bb,Pipeline: _coco_lbl -> MultiCategorize -- {'vocab': None, 'sort': True, 'add_na': True}]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coco_tds.tfms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(PILImage mode=RGB size=128x128,\n",
       " TensorBBox([[-0.9011, -0.4606,  0.1416,  0.6764],\n",
       "         [ 0.2000, -0.2405,  1.0000,  0.9102],\n",
       "         [ 0.4909, -0.9325,  0.9284, -0.5011]]),\n",
       " TensorMultiCategory([1, 1, 1]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,y,z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(y[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(z[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_close(b, tensor(bbox[0]).float())\n",
    "test_eq(c.bbox, b)\n",
    "test_eq(c.lbl, bbox[1])\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorBBox)\n",
    "test_eq(type(z), TensorMultiCategory)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorBBox)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(y.img_size, (128,128))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "coco_tdl.show_batch();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#test other direction works too\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_lbl, MultiCategorize(add_na=True)], [_coco_bb]])\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])\n",
    "\n",
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(z[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(y[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_eq(b, bbox[1])\n",
    "test_close(c.bbox, tensor(bbox[0]).float())\n",
    "test_eq(c.lbl, b)\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorMultiCategory)\n",
    "test_eq(type(z), TensorBBox)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), MultiCategory)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(z.img_size, (128,128))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_torch_core.ipynb.\n",
      "Converted 01_layers.ipynb.\n",
      "Converted 01a_losses.ipynb.\n",
      "Converted 02_data.load.ipynb.\n",
      "Converted 03_data.core.ipynb.\n",
      "Converted 04_data.external.ipynb.\n",
      "Converted 05_data.transforms.ipynb.\n",
      "Converted 06_data.block.ipynb.\n",
      "Converted 07_vision.core.ipynb.\n",
      "Converted 08_vision.data.ipynb.\n",
      "Converted 09_vision.augment.ipynb.\n",
      "Converted 09b_vision.utils.ipynb.\n",
      "Converted 09c_vision.widgets.ipynb.\n",
      "Converted 10_tutorial.pets.ipynb.\n",
      "Converted 10b_tutorial.albumentations.ipynb.\n",
      "Converted 11_vision.models.xresnet.ipynb.\n",
      "Converted 12_optimizer.ipynb.\n",
      "Converted 13_callback.core.ipynb.\n",
      "Converted 13a_learner.ipynb.\n",
      "Converted 13b_metrics.ipynb.\n",
      "Converted 14_callback.schedule.ipynb.\n",
      "Converted 14a_callback.data.ipynb.\n",
      "Converted 15_callback.hook.ipynb.\n",
      "Converted 15a_vision.models.unet.ipynb.\n",
      "Converted 16_callback.progress.ipynb.\n",
      "Converted 17_callback.tracker.ipynb.\n",
      "Converted 18_callback.fp16.ipynb.\n",
      "Converted 18a_callback.training.ipynb.\n",
      "Converted 18b_callback.preds.ipynb.\n",
      "Converted 19_callback.mixup.ipynb.\n",
      "Converted 20_interpret.ipynb.\n",
      "Converted 20a_distributed.ipynb.\n",
      "Converted 21_vision.learner.ipynb.\n",
      "Converted 22_tutorial.imagenette.ipynb.\n",
      "Converted 23_tutorial.vision.ipynb.\n",
      "Converted 24_tutorial.siamese.ipynb.\n",
      "Converted 24_vision.gan.ipynb.\n",
      "Converted 30_text.core.ipynb.\n",
      "Converted 31_text.data.ipynb.\n",
      "Converted 32_text.models.awdlstm.ipynb.\n",
      "Converted 33_text.models.core.ipynb.\n",
      "Converted 34_callback.rnn.ipynb.\n",
      "Converted 35_tutorial.wikitext.ipynb.\n",
      "Converted 36_text.models.qrnn.ipynb.\n",
      "Converted 37_text.learner.ipynb.\n",
      "Converted 38_tutorial.text.ipynb.\n",
      "Converted 39_tutorial.transformers.ipynb.\n",
      "Converted 40_tabular.core.ipynb.\n",
      "Converted 41_tabular.data.ipynb.\n",
      "Converted 42_tabular.model.ipynb.\n",
      "Converted 43_tabular.learner.ipynb.\n",
      "Converted 44_tutorial.tabular.ipynb.\n",
      "Converted 45_collab.ipynb.\n",
      "Converted 46_tutorial.collab.ipynb.\n",
      "Converted 50_tutorial.datablock.ipynb.\n",
      "Converted 60_medical.imaging.ipynb.\n",
      "Converted 61_tutorial.medical_imaging.ipynb.\n",
      "Converted 65_medical.text.ipynb.\n",
      "Converted 70_callback.wandb.ipynb.\n",
      "Converted 71_callback.tensorboard.ipynb.\n",
      "Converted 72_callback.neptune.ipynb.\n",
      "Converted 73_callback.captum.ipynb.\n",
      "Converted 74_callback.cutmix.ipynb.\n",
      "Converted 97_test_utils.ipynb.\n",
      "Converted 99_pytorch_doc.ipynb.\n",
      "Converted dev-setup.ipynb.\n",
      "Converted index.ipynb.\n",
      "Converted quick_start.ipynb.\n",
      "Converted tutorial.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
